home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: delta / whiteline CD Series - delta.iso / vision / grafics / programm / scrdump / source / scrdump.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-25  |  9.6 KB  |  399 lines
  1. #include <tos.h>
  2. #include <linea.h>
  3. #include <vdi.h>        /* nur für MFDB!! */
  4. #include <stdlib.h>
  5.  
  6. #include "sdump.h"
  7.  
  8. #ifndef GEMDUMP
  9.     extern SCREEN_DUMP dump;
  10. #    define inst        dump.inst
  11. #    define scr_nr    dump.nr
  12. #else
  13.     extern INST inst;
  14.     extern int scr_nr;
  15. #endif
  16.  
  17. /*
  18.     fehlerbehandlung
  19. */
  20. int xerr;
  21.  
  22. int h_error(long err,long z)
  23. {
  24.     if ( err<0L || ((z!=0L)&&(err!=z) ) ) {
  25.         xerr=(int)err;
  26.         if ( err>0l )
  27.             xerr=-1000;
  28.         return 1;
  29.     }
  30.     return 0;
  31. }
  32.  
  33. /*
  34.     gepufferte schreibroutinen
  35. */
  36. int f_id,z;        /* f_id: file-id, z: schreibpostiotion im puffer */
  37. char *w_buf;    /* zeigt auf puffer der größe BUF_SIZE */
  38. static void init_write(char *puffer)
  39. {
  40.     w_buf=puffer;
  41.     z=0;
  42. }
  43.  
  44. static int write_byte(char byte)        /* schreibe ein byte gepuffert */
  45. {
  46.     w_buf[z++]=byte;
  47.     if ( z==BUF_SIZE ) {
  48.         if ( h_error(Fwrite(f_id,BUF_SIZE,w_buf),BUF_SIZE) )
  49.             { Fclose(f_id); return 1; }
  50.         z=0;
  51.     }
  52.     return 0;
  53. }
  54.  
  55.                                         /* schreibe block gepuffert */
  56. static int write_block(long len,char *block)
  57. {
  58. long i;
  59.     for ( i=0; i<len; i++,block++ )
  60.         if ( write_byte(*block) )
  61.             return 1;
  62.     return 0;
  63. }
  64.  
  65.                                         /* schreibe restpuffer & schließe datei */
  66. static int close_write(void)
  67. {
  68.     if ( z!=0 ) {
  69.         if ( h_error(Fwrite(f_id,(long)z,w_buf),(long)z) )
  70.             { Fclose(f_id); return 1; }
  71.         z=0;
  72.     }
  73.     return 0;
  74. }
  75.  
  76.                                         /* schreibe ungepackte daten (für img) */
  77. static int write_upk(int len,char *unpacked)
  78. {            
  79.     if ( write_byte(0x80) || write_byte(len) )
  80.         return 1;
  81.     return write_block(len,unpacked);
  82. }
  83.  
  84. /*
  85.     initialisiere strukturen für xIMG-Datei
  86. */
  87. static void init_img(SAVE_IMG *img,IMG_HEAD *head,MFDB *mfdb,int w,int h,char *line,int llen,int pix_wid,int pix_hght)
  88. {
  89.     img->line=line;                                /* zeilenbuffer */
  90.     img->pic_line=img->pic_buf=mfdb->fd_addr;    /* bildbuffer */
  91.     img->flag=img->line_nr=0;                    /* laufvariable */
  92.  
  93.     img->bwid=w/8;                                /* ausmaße */
  94.     if ( w%8 )
  95.         img->bwid++;
  96.     if ( img->bwid>llen/mfdb->fd_nplanes )
  97.         img->bwid=llen/mfdb->fd_nplanes;
  98.     img->hght=h;
  99.  
  100.     img->pic_bwid=mfdb->fd_wdwidth*2;            /* breite der bitmap */
  101.     if ( !mfdb->fd_stand )
  102.         img->pic_bwid*=mfdb->fd_nplanes;
  103.  
  104.     img->plane_size=(long)mfdb->fd_wdwidth*2l*mfdb->fd_h;
  105.  
  106.     img->standard=mfdb->fd_stand;
  107.  
  108.     head->ver_num=0;                            /* dateiheader */
  109.     head->head_len=8;
  110.     head->pat_len=2;
  111.  
  112.     head->pix_wid=(pix_wid==-1)?0x174:pix_wid;
  113.     head->pix_hght=(pix_hght==-1)?0x174:pix_hght;
  114.     img->planes=mfdb->fd_nplanes;
  115.  
  116.     head->plane_num=mfdb->fd_nplanes;
  117.     head->pix_num=w;
  118.     if ( w>llen/mfdb->fd_nplanes*8 )
  119.         head->pix_num=llen/mfdb->fd_nplanes*8;
  120.     head->scan_num=h;
  121. }
  122.  
  123. /*
  124.     lese/vergleiche zeile
  125. */
  126. static int get_line(SAVE_IMG *img,int mode)
  127. {
  128. char *h1,*h2;
  129. int cnt,i,ii;
  130.  
  131.     if ( img->flag==-1 || (img->flag && mode) )
  132.         return 0;
  133.  
  134.     h1=img->line;
  135.  
  136.     if ( !img->standard ) {                /* st-screen format */
  137.       int offset;
  138.         if ( mode ) {    /* nur testen */
  139.             for ( i=0,offset=0; i<img->planes; i++,offset+=2 ) {
  140.                 for ( cnt=0,h2=img->pic_line+offset; cnt<img->bwid; h2+=2*(img->planes-1) )
  141.                     for ( ii=0; ii<2 && cnt<img->bwid; ii++,cnt++ )
  142.                         if ( *h1++!=*h2++ )
  143.                             return 0;
  144.             }
  145.         }
  146.         else {            /* kopieren */
  147.             for ( i=0,offset=0; i<img->planes; i++,offset+=2 ) {
  148.                 for ( cnt=0,h2=img->pic_line+offset; cnt<img->bwid; h2+=2*(img->planes-1) )
  149.                     for ( ii=0; ii<2 && cnt<img->bwid; ii++,cnt++ )
  150.                         *h1++=*h2++;
  151.             }
  152.             img->flag=0;
  153.         }
  154.     }
  155.     else {                                /* standard format */
  156.       long offset;
  157.         if ( mode ) {    /* nur testen */
  158.             for ( i=0,offset=0l; i<img->planes; i++,offset+=img->plane_size ) {
  159.                 for ( cnt=0,h2=img->pic_line+offset; cnt<img->bwid; cnt++ )
  160.                     if ( *h1++!=*h2++ )
  161.                     return 0;
  162.             }
  163.         }
  164.         else {            /* kopieren */
  165.             for ( i=0,offset=0l; i<img->planes; i++,offset+=img->plane_size ) {
  166.                 for ( cnt=0,h2=img->pic_line+offset; cnt<img->bwid; cnt++ )
  167.                     *h1++=*h2++;
  168.             }
  169.             img->flag=0;
  170.         }
  171.     }
  172.  
  173.     img->pic_line+=img->pic_bwid;
  174.     img->line_nr++;
  175.     if ( img->line_nr==img->hght ) {    /* ende erreicht */
  176.         img->flag=-1;
  177.     }
  178.     return 1;
  179. }
  180.  
  181. /*
  182.     schreibe block (0,0,wid,hght) aus 'buffer' in xIMG-Datei 'name'
  183.     'col' zeigt auf farbtabelle, 'xflag' gibt an ob IMG (DO_XIMG false) oder 
  184.     xIMG (DO_XIMG true)
  185.     geschrieben werden soll (falls xflag==0 ist col redundand und wird nicht beachtet)
  186.  
  187.     falls GEMDUMP nicht (mit -DGEMDUMP) in den compileroptionen gesetzt ist
  188.     wird bei gesetztem xflag und 'col==0l' statt der farbtabelle in col
  189.     die farben via xbios ermittelt und geschrieben!
  190.  
  191.     rückgabewert: 0 ok
  192.                   <0 gemdos/bios fehlernummer oder
  193.                        -1000 für 'zu wenig daten geschrieben bei fwrite'
  194. */
  195. #define DO_XIMG        ((header.plane_num>1 && xflag&1) || xflag&2)
  196.             /* true -> schreibe ximg, false -> kein ximg */
  197. int do_store_img(char *name,MFDB *buffer,int wid,int hght,COLOR *col,int xflag,int pix_wid,int pix_hght)
  198. {
  199. char *line;
  200. static char lline[MAX_LINE_LEN],unpacked[256];
  201. static char buf[BUF_SIZE];
  202. static IMG_HEAD header;
  203. static SAVE_IMG img;
  204. int cnt,len,i;
  205. char *h;
  206.  
  207.     if ( h_error((long)(f_id=Fcreate(name,0)),0L) )
  208.         return xerr;
  209.  
  210.     init_write(buf);    /* init für write_byte */
  211.  
  212.     line=lline;
  213.  
  214.     init_img(&img,&header,buffer,wid,hght,line,MAX_LINE_LEN,pix_wid,pix_hght);
  215.  
  216.  
  217.     /*
  218.         header modifizieren für ximg
  219.     */
  220.     if ( DO_XIMG )
  221.         header.head_len+=3+3*(1<<header.plane_num);
  222.  
  223.     /*
  224.         header schreiben
  225.     */
  226.     for ( h=(char*)&header,len=0; len<16; len++,h++ )
  227.         if ( write_byte(*h) )
  228.             { Fclose(f_id); return xerr; }
  229.  
  230.  
  231.     /*
  232.         ximg schreiben
  233.     */
  234.     if ( DO_XIMG ) {
  235.         if ( write_byte('X') || write_byte('I') || write_byte('M') || write_byte('G')
  236.                 || write_byte(0) || write_byte(0) )
  237.                 { Fclose(f_id); return xerr; }
  238.         len=(int)sizeof(COLOR)*(1<<header.plane_num);
  239.  
  240. #ifndef GEMDUMP
  241.         if ( col ) {
  242. #endif
  243.             for ( h=(char*)col; len>0; h++,len-- )
  244.                 if ( write_byte(*h) )
  245.                     { Fclose(f_id); return xerr; }
  246. #ifndef GEMDUMP
  247.         }
  248.         else {    /* farben nicht gesetzt -> via xbios holen */
  249.           COLOR col;
  250.           int i,c;
  251.             for ( i=0; i<(1<<buffer->fd_nplanes); i++ ) {
  252.                 c=Setcolor(i,-1);
  253.                 col.red=(((c>>8)&7)*1000)/7;
  254.                 col.green=(((c>>4)&7)*1000)/7;
  255.                 col.blue=((c&7)*1000)/7;
  256.                 for ( h=(char*)&col,len=(int)sizeof(COLOR); len>0; h++,len-- )
  257.                     if ( write_byte(*h) )
  258.                         { Fclose(f_id); return xerr; }
  259.             }
  260.         }
  261. #endif
  262.     }
  263.  
  264.     /*
  265.         schreibe graphikdaten
  266.     */
  267.     while ( get_line(&img,0) ) {
  268.         cnt=1;
  269.         while ( cnt<255 && get_line(&img,1) ) {        /* gleiche zeilen? */
  270.             cnt++;
  271.         }
  272.         if ( cnt>1 ) {                                /* zeilenwiederholung eintragen */
  273.             if ( write_byte(0) || write_byte(0) || write_byte(0xFF) || write_byte(cnt) )
  274.                 { Fclose(f_id); return xerr; }
  275.         }
  276.  
  277.         h=line;                                        /* zeile schreiben */
  278.         for ( i=0; i<img.planes; i++ ) {
  279.             for ( len=cnt=0; cnt<img.bwid; ) {
  280.                 if ( (*h==0 && *(h+1)==0) || (*h==0xFF && *(h+1)==0xFF) ) {
  281.                   char muster;                        /* solid run */
  282.                     if ( len ) {
  283.                         if ( write_upk(len,unpacked) )
  284.                             { Fclose(f_id); return xerr; }
  285.                     }
  286.                     len=0;
  287.                     muster=*h;
  288.                     while ( *h==muster && cnt<img.bwid && len<63 )
  289.                         len++,cnt++,h++;
  290.                     if ( muster!=0 )
  291.                         len|=128;
  292.                     if ( write_byte(len) )
  293.                         { Fclose(f_id); return xerr; }
  294.                     len=0;
  295.                 }
  296.                 else if ( cnt+5<img.bwid && *h==*(h+1) && *h==*(h+2) && *h==*(h+3) && *h==*(h+4) ) {
  297.                   char muster_lo,muster_hi;            /* pattern run */
  298.                   char *h1,*h2;
  299.                     if ( len ) {
  300.                         if ( write_upk(len,unpacked) )
  301.                             { Fclose(f_id); return xerr; }
  302.                     }
  303.                     len=0;
  304.                     h1=h;
  305.                     h2=h1+1;
  306.                     muster_lo=*h1;
  307.                     muster_hi=*h2;
  308.                     while ( *h1==muster_lo && *h2==muster_hi && cnt<img.bwid-1 && len<255 )
  309.                         len++,cnt+=2,h1+=2,h2+=2;
  310.                     if ( write_byte(0) || write_byte(len) || write_byte(muster_lo) || write_byte(muster_hi) )
  311.                         { Fclose(f_id); return xerr; }
  312.                     h=h1;
  313.                     len=0;
  314.                 }
  315.                 else {                                /* unpacked */
  316.                     unpacked[len++]=*h++;
  317.                     cnt++;
  318.                     if ( len==255 ) {
  319.                         if ( write_upk(len,unpacked) )
  320.                             { Fclose(f_id); return xerr; }
  321.                         len=0;
  322.                     }
  323.                 }
  324.             }
  325.             if ( len ) {
  326.                 if ( write_upk(len,unpacked) )
  327.                     { Fclose(f_id); return xerr; }
  328.             }
  329.         }
  330.     }
  331.  
  332.     if ( close_write() )
  333.         { return xerr; }
  334.     h_error((long)Fclose(f_id),0L);
  335.  
  336.     return 0;
  337. }
  338.  
  339. /*
  340.     erzeuge namen für screendump
  341.         scr_nr ist zähler für bildnummer
  342. */
  343. void make_name(char *name)
  344. {
  345. char *d,*s,nr[10];
  346.  
  347.     for ( d=name,s=inst.file; *s!=0; )    /* kopiere dump_file nach name */
  348.         *d++=*s++;
  349.     itoa(scr_nr,nr,10);    /* don't use sprintf here (exceeds prg-size) */
  350.     scr_nr++;
  351.     for ( s=nr; *s!=0; )                /* strcat nr an name */
  352.         *d++=*s++;
  353.     for ( s=".IMG"; *s!=0; )
  354.         *d++=*s++;
  355.     *d=0;
  356. }
  357.  
  358. #ifndef GEMDUMP                            /* verwaltet zugriff auf fullscreen */
  359.                                         /* mittels scr->fd_addr==0l */
  360.                                         /* liest parameter via XBIOS (Logbase) */
  361.                                         /* Vdiesc/LineA-Variable */
  362.                                         /* dx==0 -> fullscreen */
  363.                                         /* dy==0 -> fullscreen */
  364. int store_img(char *name,MFDB *scr,int dx,int dy,COLOR *col,int xflag,int pix_wid,int pix_hght)
  365. {
  366.     if ( scr->fd_addr==0l ) {
  367.         linea_init();
  368.         scr->fd_addr=Logbase();
  369.         scr->fd_wdwidth=Vdiesc->bytes_lin/2/Linea->v_planes;
  370.                                         /* notwendig für overscan (dann ungleich dx/16!!) */
  371.         scr->fd_w=Vdiesc->v_rez_hz;
  372.         scr->fd_h=Vdiesc->v_rez_vt;
  373.         scr->fd_nplanes=Linea->v_planes;
  374.         scr->fd_stand=0;                /* geräteformat */
  375.     }
  376.     if ( dx==0 )
  377.         dx=scr->fd_w;
  378.     if ( dy==0 )
  379.         dy=scr->fd_h;
  380.  
  381.     if ( do_store_img(name,scr,dx,dy,col,xflag,pix_wid,pix_hght) )
  382.         return xerr;
  383.  
  384.     return 0;
  385. }
  386.  
  387. void do_althelp(void)                    /* aufruf von althelp */
  388. {
  389. MFDB scr;
  390. char name[64];
  391.  
  392.     make_name(name);
  393.  
  394.     scr.fd_addr=0l;                        /* access screen */
  395.     store_img(name,&scr,0,0,0l,inst.ximg,-1,-1);
  396. }
  397. #endif
  398.  
  399.